Discrete event simulators are important scientific tools and their efficient design and execution is the subject of much research. From physics to biology, from weather forecasting to predicting the performance of a new processor design, researchers in many avenues of science increasingly depend on software simulations to model various realistic phenomena or hypothetical scenarios that often cannot be satisfactorily expressed analytically nor easily reproduced and observed empirically. Instead, simulation models are derived and then encoded as discrete event-driven programs: events are time-stamped messages processed in their temporal order as the simulator progresses through simulated time; event processing involves updating the simulation program state according to the given model and possibly scheduling more events in the future.
Recent research focused on networking and distributed systems communities on wireless ad hoc networks has fundamentally depended on simulation. Simulating an ad hoc network, or any other phenomenon, requires an accurate computational model that is nevertheless efficient. An objective of such research is to develop a sufficiently abstract representation of the state and of the state changes that can nonetheless produce meaningful, reliable results. For example, simulation time can often be discretized to produce discrete event simulations, which can be readily encoded as event-driven programs. Events are time-stamped messages, processed in their temporal order. Processing an event involves updating the simulation state according to the given model, and potentially scheduling more events in the future.
Simulation systems researchers have built many types of conservatively parallel and aggressively optimistic kernels and libraries, while the languages community has designed numerous simulation languages that codify event causality and execution semantics and simulation state constraints.
Some simulation systems use kernels, including systems such as the seminal TIMEWARP™ OS (See Johnson, et al., “Validation of wireless and mobile network models and simulation”, Proceedings of the DARPA/NIST Workshop on Validation of Large-Scale Network Models and Simulation, May 1990), that transparently create convenient simulation time abstractions. By mimicking the system call interface of a conventional operating system, a kernel can execute simulations comprised of standard, unmodified programs. Further, since the kernel controls process scheduling, inter-process communication and the system clock, the kernel can run its applications in simulation time and can enforce process boundaries.
Some simulation systems use simulation libraries to combine individual processes to eliminate process context-switching and marshalling overheads required for event dispatch. In this case, message passing and scheduling, formerly kernel functions, must be explicitly programmed in user-space. In essence, the kernel and its applications are merged into a single monolithic program that contains both the simulation model as well as its own execution engine. This monolithic simulation program can be complex and not easily amenable to transparent parallelization and function distribution.
Some simulation programs are written in programming languages that are specifically written to accommodate simulations, such as SIMULA and PARSEC. These languages are designed to simplify simulation development and to explicitly enforce the correctness of monolithic simulation programs. Simulation languages often introduce execution semantics that transparently allow for parallel and speculative execution, without any program modification. Such languages often also introduce handy constructs, such as messages and entities, that can be used to partition the application state. Constraints on simulation state and on event causality are statically enforced by the compiler, and they also permit important static and dynamic optimizations. However, despite these advantages, simulation languages can suffer from specialization relative to general-purpose computing languages, such as C, JAVA®, LISP, etc. While simulation languages offer handy simulation-oriented features, they usually lack features such as type safety, reflection, and garbage collection, as well as portability. They can also lag in terms of general-purpose optimizations and implementation efficiency.
Each of these three fundamental approaches to simulation construction (i.e., kernel-based, library-based, and language-based) trades off one of three desirable properties—standardization, efficiency or transparency—where:                standardization means writing simulations in a conventional, popular programming language, as opposed to a domain-specific language designed explicitly for simulation;        efficiency denotes optimizing the simulation program statically and dynamically by considering simulation state and event causality constraints in addition to general-purpose optimizations, creating a simulation engine that compares favorably with existing, highly optimized systems both in terms of simulation throughput and memory consumption, and, possibly distributing the simulation and executing it in parallel or speculatively to improve performance; and        transparency implies the separation of efficiency from correctness; that correct simulation programs can be automatically transformed to run efficiently without the insertion of simulation-specific library calls or other program modifications. Correctness is an assumed pre-condition that simulation programs must compute valid and useful results, regardless of how they are constructed.        
With respect to simulating communication networks, even though a number of parallel discrete event simulation environments can scale beyond 104 nodes, slow sequential simulators remain the norm. In particular, most published ad hoc network results are based on simulations of a limited number of nodes (usually only around 200 nodes), for a short duration (frequently just 90 seconds), and over a limited field. Larger simulations usually compromise on simulation detail or restrict node mobility.
Therefore, what is needed is a simulation system that does not involve creation of a new simulation language, nor a simulation library, nor a new system kernel or language runtime for simulation. What is needed is a simulation system that focuses on maximizing sequential simulation performance as well as effective distribution and parallelism.